home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 7: Sunsite / Linux Cubed Series 7 - Sunsite Vol 1.iso / system / emulator / bsvc-1.000 / bsvc-1 / bsvc-1.0.4 / src / Assemblers / 68kasm / symbol.c < prev   
C/C++ Source or Header  |  1995-07-26  |  4KB  |  169 lines
  1. /******************************************************************************
  2.  * $Id: symbol.c,v 1.1 1994/08/30 00:05:31 bmott Exp $
  3.  ******************************************************************************
  4.  *
  5.  *        SYMBOL.C
  6.  *        Symbol Handling Routines for 68000 Assembler
  7.  *
  8.  *    Function: lookup()
  9.  *        Searches the symbol table for a previously defined
  10.  *        symbol or creates a new symbol. The routine functions
  11.  *        as follows: 
  12.  *
  13.  *        Symbol
  14.  *        Found                  Returned
  15.  *        In    Create      Action      Error
  16.  *        Table?  Flag      Taken          Code
  17.  *        ------  ------    --------------  -----------
  18.  *          N     FALSE     None          UNDEFINED
  19.  *          N     TRUE      Symbol created  OK
  20.  *          Y     FALSE     None          OK
  21.  *          Y    TRUE      None          MULTIPLE_DEFS
  22.  *
  23.  *        In addition, the routine always returns a pointer to
  24.  *        the structure (type symbolDef) that which contains the
  25.  *        symbol that was found or created. The routine uses a 
  26.  *        hash function to index into an array of pointers to 
  27.  *        ordered linked lists of symbol definitions.
  28.  *
  29.  *        define()
  30.  *        Defines the symbol whose name is specified to have the
  31.  *        value specified. If check is TRUE, then the symbol is
  32.  *        is assumed to already exist and its value is checked 
  33.  *        against the passed value; a PHASE_ERROR results if the
  34.  *        values are not the same. When check is TRUE the routine
  35.  *        also sets the backRef bit for the symbol. If check is
  36.  *        FALSE, then the symbol is defined and its value is set
  37.  *        equal to the supplied number. The function returns a 
  38.  *        pointer to the symbol definition structure.
  39.  *
  40.  *     Usage:    symbolDef *lookup(sym, create, errorPtr)
  41.  *        char *sym;
  42.  *        int create, *errorPtr;
  43.  *
  44.  *         symbolDef *define(sym, value, check, errorPtr)
  45.  *        char *sym;
  46.  *        int value, check, *errorPtr;
  47.  *
  48.  *      Author: Paul McKee
  49.  *        ECE492    North Carolina State University
  50.  *
  51.  *        Date:    11/28/86
  52.  *
  53.  *   Copyright 1990-1991 North Carolina State University. All Rights Reserved.
  54.  *
  55.  ******************************************************************************
  56.  * $Log: symbol.c,v $
  57.  * Revision 1.1  1994/08/30  00:05:31  bmott
  58.  * Initial revision
  59.  *
  60.  *****************************************************************************/
  61.  
  62.  
  63. #include <stdio.h>
  64. #include <ctype.h>
  65. #include "asm.h"
  66.  
  67. /* MAXHASH is the range of the hash function. hash()
  68.    returns values from 0 to MAXHASH inclusive. */
  69.     
  70. #define MAXHASH 26
  71.  
  72. static symbolDef *htable[MAXHASH+1];
  73.  
  74.  
  75. symbolDef *lookup(sym, create, errorPtr)
  76. char *sym;
  77. int create, *errorPtr;
  78. {
  79. int h, cmp;
  80. symbolDef *s, *last, *t;
  81. static char initialized = FALSE;
  82.  
  83.     if (!initialized) {
  84.         for (h = 0; h <= MAXHASH; h++)
  85.             htable[h] = 0;
  86.         initialized = TRUE;
  87.         }
  88.  
  89.     h = hash(sym);
  90.     if (s = htable[h]) {
  91.         /* Search the linked list for a matching symbol */
  92.         last = NULL;
  93.         while (s && (cmp = strcmp(s->name, sym)) < 0) {
  94.             last = s;
  95.             s = s->next;
  96.             }
  97.         /* If a match was found, return pointer to the structure */
  98.         if (s && !cmp) {
  99.             if (create)
  100.                 NEWERROR(*errorPtr, MULTIPLE_DEFS);
  101.             t = s;
  102.             }
  103.         /* Otherwise insert the symbol in the list */
  104.         else if (create)
  105.             if (last) {
  106.                 /* The symbol goes after an existing symbol */
  107.                 t = (symbolDef *) malloc(sizeof(symbolDef));
  108.                 last->next = t;
  109.                 t->next = s;
  110.                 strcpy(t->name, sym);
  111.                 }
  112.             else {
  113.                 /* The symbol goes at the head of a list */
  114.                 t = (symbolDef *) malloc(sizeof(symbolDef));
  115.                 t->next = htable[h];
  116.                 htable[h] = t;
  117.                 strcpy(t->name, sym);
  118.                 }
  119.         else
  120.             NEWERROR(*errorPtr, UNDEFINED);
  121.         }
  122.     else if (create) {
  123.         t = (symbolDef *) malloc(sizeof(symbolDef));
  124.         htable[h] = t;
  125.         t->next = NULL;
  126.         strcpy(t->name, sym);
  127.         }
  128.     else
  129.         NEWERROR(*errorPtr, UNDEFINED);
  130.     return t;
  131. }                
  132.             
  133.  
  134. int hash(symbol)
  135. char *symbol;
  136. {
  137. int sum;
  138.  
  139.     sum = 0;
  140.     while (*symbol) {
  141.         sum += (isupper(*symbol)) ? (*symbol - 'A') : 26;
  142.         symbol++;
  143.         }
  144.     return (sum % 27);
  145. }
  146.  
  147.  
  148. symbolDef *define(sym, value, check, errorPtr)
  149. char *sym;
  150. int value, check, *errorPtr;
  151. {
  152. symbolDef *symbol;
  153.  
  154.     symbol = lookup(sym, !check, errorPtr);
  155.     if (*errorPtr < ERROR)
  156.         if (check) {
  157.             if (symbol->value != value)
  158.                 NEWERROR(*errorPtr, PHASE_ERROR);
  159.             symbol->flags |= BACKREF;
  160. /*            printf("Marking symbol \"%s\"\n", sym); */
  161.             }
  162.         else {
  163. /*            printf("Defining the symbol \"%s\" as %08X.\n", sym, value); */
  164.             symbol->value = value;
  165.             symbol->flags = 0;
  166.             }
  167.     return symbol;
  168. }
  169.